package com.ifeng.shopping.util;

import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.LinearGradient;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PorterDuff.Mode;
import android.graphics.PorterDuffXfermode;
import android.graphics.Shader.TileMode;
import android.os.AsyncTask;
import android.os.Handler.Callback;
import android.os.Message;
import android.util.Log;
import android.widget.ImageView;

public class CanvasImageTask extends UserTask<ImageView, Void, Bitmap> implements Callback{
    private ImageView gView ;
    
    public Bitmap onBackgroundExecute(ImageView... views) {
            Bitmap bmp = null ;
            ImageView view = views[0];
            // 根据iconUrl获取图片并渲染，iconUrl的url放在了view的tag中。
            if (view.getTag() != null) {
                    try {
                    	String line = view.getTag().toString();
                       URL url = new URL(line);
                       HttpURLConnection conn = (HttpURLConnection)url.openConnection();
                       conn.setDoInput(true);
                       conn.connect();
                       InputStream stream = conn.getInputStream();
                       bmp = BitmapFactory.decodeStream(stream);
                       stream.close();
                    } catch (Exception e) {
                          
                            Message msg = new Message();
                            msg.what = 0;
                            handleMessage(msg);
                            return null;
                    }
            }
            this.gView = view;
            
            return bmp;
    }
    
    
    public static Bitmap createReflectedImage(Bitmap originalImage) {  

    	         // The gap we want between the reflection and the original image  

    	         final int reflectionGap = 0;  

    	    

    	         int width = originalImage.getWidth();  

    	         int height = originalImage.getHeight();  

    	    

    	         // This will not scale but will flip on the Y axis  

    	         Matrix matrix = new Matrix();  

    	         matrix.preScale(1, -1);  

    	    

    	         // Create a Bitmap with the flip matrix applied to it.  

    	         // We only want the bottom half of the image  

    	         Bitmap reflectionImage = Bitmap.createBitmap(originalImage, 0,  

    	                 height / 2, width, height / 2, matrix, false);  

    	    

    	         // Create a new bitmap with same width but taller to fit reflection  

    	         Bitmap bitmapWithReflection = Bitmap.createBitmap(width,  

    	                 (height + height / 2), Config.ARGB_8888);  

    	    

    	         // Create a new Canvas with the bitmap that's big enough for  

    	         // the image plus gap plus reflection  

    	         Canvas canvas = new Canvas(bitmapWithReflection);  

    	         // Draw in the original image  

    	         canvas.drawBitmap(originalImage, 0, 0, null);  

    	         // Draw in the gap  

    	         Paint defaultPaint = new Paint();  

    	         canvas.drawRect(0, height, width, height + reflectionGap, defaultPaint);  

    	         // Draw in the reflection  

    	         canvas.drawBitmap(reflectionImage, 0, height + reflectionGap, null);  

    	    

    	         // Create a shader that is a linear gradient that covers the reflection  

    	         Paint paint = new Paint();  

    	         LinearGradient shader = new LinearGradient(0,  

    	                 originalImage.getHeight(), 0, bitmapWithReflection.getHeight()  

    	                         + reflectionGap, 0x70ffffff, 0x00ffffff, TileMode.CLAMP);  
    	         // Set the paint to use this shader (linear gradient)  

    	         paint.setShader(shader);  

    	         // Set the Transfer mode to be porter duff and destination in  

    	         paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN));  

    	         // Draw a rectangle using the paint with our linear gradient  

    	         canvas.drawRect(0, height, width, bitmapWithReflection.getHeight()  

    	                 + reflectionGap, paint);  

    	    

    	         return bitmapWithReflection;  

    	     }  

    public void onPostExecute(Bitmap bm) {
            if (bm != null) {
                this.gView.setImageBitmap(bm);
                this.gView.setTag(bm);
                this.gView = null ;
                Message msg = new Message();
                msg.what = 1;
                handleMessage(msg);
            }
    }

    public boolean handleMessage(Message msg) {
        // TODO Auto-generated method stub
        return false;
    }


	@Override
	protected void onErrorHandle(Context context, Exception error) {
		// TODO Auto-generated method stub
		
	}


	@Override
	protected void onTaskFinished(Context context, Bitmap result) {
		// TODO Auto-generated method stub
		
	}


}